In computer science, a mobile agent is a composition of computer software and data, which is able to migrate from one server to another autonomously and continue its execution on a destination server. A mobile agent inherits some of the characteristics of an agent. An agent is a computational entity that acts on behalf of other entities in an autonomous fashion, performs its actions with some level of proactivity and/or reactiveness and exhibits some level of key attributes of learning, co-operation and mobility. A mobile agent, namely, is a type of a software agent, with the feature of autonomy, social ability, learning, and most important, mobility. When the term mobile agent is used, it refers generally to a process that can transport its state from one environment to another, with its data intact, and still being able to perform appropriately in the new environment. The mobile agent environment is, generally speaking, a software system that is distributed over a network system of heterogeneous servers. Its primary task is to provide an environment in which mobile agents can execute. The mobile agent environment is built on top of a host system. Mobile agents travel between mobile agent environments. They can communicate with each other either locally or remotely. Finally, communication can also take place between a mobile agent and a host service. Mobile agents are active in that they may choose to migrate between servers at any time during the execution. This makes them a powerful tool for implementing distributed applications in a network system. During their route through the network system, mobile agents can carry data with them. These data can be data that are necessary for their execution on a certain server and results from calculations that have been performed on a certain server. The route of a mobile agent can be defined in advance, or the mobile agent can adapt its route on its way based on certain events. After the completion of their tasks, most mobile agents return to their departure point to return the results they gathered.
There are quite a lot of advantages of using mobile agents, which are described in the following. Mobile agents reduce network traffic. Some applications first download a large amount of data from a server and then process this data to a smaller amount, e.g., search and filter applications, such as, for example, data-mining. If one would use mobile agents for these programs, then these mobile agents would be able to execute the work on the server itself, without congesting the network system because only the results of the calculation would be sent back.
Furthermore, by means of mobile agents, an asynchronous and autonomous execution on multiple heterogeneous network servers is possible. Some applications need a large amount of client-server interactions which can be done through classic client-server method invocations or with web services used in a so-called Enterprise Services Architecture (ESA). Also in this case mobile agents can be more efficient. A mobile agent can work asynchronously and autonomously while the system that sent the mobile agent is no longer connected to the network system. Mobile servers like laptops and PDAs, that mostly have an uncertain and expensive connection with relative low bandwidth, can therefore make proper use of mobile agents.
Moreover, mobile agents have the possibility to adopt themselves to changes in their execution environment. This is why mobile agents can be used, for example, in load-balancing. When a server is starting to become overloaded, some processes can be placed to another server within the network system in the form of a mobile agent, where they can continue their execution. Also, other application scenarios exist where intelligent agents can make efficient decisions based on the changing execution environment. An e-business scenario with mobile agents would allow, for example, finding the cheapest price for an airplane ticket, car rental and hotel booking. Most airlines have deals with car rental companies and hotels. This information would be available when the mobile agent will visit the server of the airline company. The mobile agent would collect the prices of the airplane ticket and then continues its route to the service of cooperating car rental companies and hotels.
As already mentioned, the use of mobile agents is tolerant to network faults. Mobile agents are able to operate without an active connection between a client and a server.
Common applications of mobile agents include, for example, resource availability, discovery, monitoring, information retrieval, network management and dynamic software deployment.
If one wants to execute a mobile agent on a server, then this mobile agent comes under the complete control of the server. If a server has malicious intentions and wants to change the mobile agent or simply delete the mobile agent, this is impossible to prevent. However, it can be attempted to make targeted, malicious changes impossible by applying detection mechanisms. With cryptographic techniques one can try to make sure that the server cannot read information that is not targeted towards it. The fact that the mobile agent travels from one server to another means, however, that classic methods are not sufficient anymore to protect these mobile agents.
There are some existing methods to protect mobile agents against servers. Generally, there are two categories of existing methods to protect mobile agents against servers, namely so-called Blackbox methods and Partial Protection methods.
The goal of Blackbox methods is to hide the whole program code of a mobile agent for a server, so that the intention of the mobile agent is not clear and the server will not be able to make targeted modifications. There are basically three different approaches in this category.
A first approach can be called “Tamper-free Hardware.” One can use here a special manufactured tool as an execution environment for the mobile agents. The internal specifications of the system are physically separated from the outside world and impossible to maintain without damaging the tool, which can be easily verified. This approach gives a very good protection. However, it is practically unacceptable on a large scale because of the high manufacturing costs. For more information reference is made to “U. G. Wilhelm, S. Staamann, L. Buttyan. Introducing Trusted Third Parties to the Mobile Agent Paradigm. In J. Vitek and C. Jensen, Secure Internet Programming: Security Issues for Mobile and Distributed Objects, volume 1603, pages 471-491. Springer-Verlag, New York, N.Y., USA, 1999” and “Bennet Yee. Using Secure Coprocessors. PhD Thesis, May 1994.”
A further approach can be called “Obfuscated Code.” This approach tries to rearrange the code of the mobile agent in such a way that it becomes incomprehensible, but still has the same effect. The technique is closely related to obfuscation techniques to prevent reverse engineering. At this moment there is no method that makes the code incomprehensible infinitely in time. If one has enough processing capacity, one can rediscover the meaning of the code. A less strict variant of this approach is the time limited protection, i.e., the obfuscated code is only valid for a certain period in time, after which the mobile agent becomes invalid. A large problem here is that one has not yet defined ways to calculate the effectiveness of the obfuscation algorithms. In other words, it is not possible to calculate an underlimit for the time. More information can be found in “Fritz Hohl, Time Limited Blackbox Security: Protecting Mobile Agents from Malicious Hosts. In Giovanni Vigna, Mobile Agent Security, pages 92-113. Springer-Verlag. 1998.”
A further approach refers to Mobile Cryptography. Suppose one has an algorithm to calculate a function f and one wants to know from a certain input value x the function value f(x) on a server without the server knowing f. This would be possible if one could encrypt f in a way that E[f(x)], the function value of x calculated with the encrypted function, could be decrypted back to f(x). This technique is very promising, but the biggest challenge remains to develop encryption schemas E for arbitrary functions f. For now E exists only for certain classes of polynomials and rational functions as it is described in reference “T. Sander and C. Tschudin. Towards Mobile Cryptography. In Proceedings of the IEEE Symposium on Security and Privacy, Oakland, Calif., 1998.”
Instead of covering the whole mobile agent for the servers in the approach of partial protection, part of the mobile agent will be protected, like confidential information that the mobile agent carries with him. In this case, however, the servers can perform targeted attacks against the mobile agents, which was not possible with blackbox methods. The mobile agents are vulnerable to so-called cut-and-paste attacks. One can remove data from a mobile agent and use another mobile agent to get to know the confidential information.
The purpose of an existing method described in the following and further described in reference “Neeran M. Karnik and Anand R. Tripathi. Security in the Ajanta mobile agent system. Software, Practice and Experience, 31(4): 301-329, 2001,” is to make data that the mobile agent carries with him only accessible to certain servers. It is assumed in the following that the servers within the network system are all provided with a pair of a public key and a private key, respectively. One could try to make data that a mobile agent carries with it only accessible to certain servers by encrypting those data with the respective public keys of the servers. To check the integrity and the authenticity of the data one can then also calculate a digital signature on the whole. This can be described by the following mathematical term:[{m1}KS1, . . . , {mn}KSn]PKS0   (1)where mi is a message for a server Si, KSi is the public key of server Si, and PKS0 is the private key of the owner of the respective mobile agent, namely server S0.
When a mobile agent arrives on a certain server, this server verifies first the signature on the whole data structure with the public key of the agent owner. After this step, the server checks if the mobile agent carries messages that are destined for that server. If this is the case, the respective server can decrypt these messages with its private key and makes them available to the mobile agent, if appropriate.
This described method makes use of classic cryptographic techniques to protect the data of the mobile agent. However, because the mobile agents migrate from one server to another before returning to their home server, the mobile agents need additional protection. This will become clear from the description of the following approach.
To clarify the attack described in the following, the assumption is made that the mobile agent only carries one message. The server owning the mobile agent as well as each server within the network system is associated with a pair of a public key and a private key, respectively. Suppose that a server A wants to send a secret message to a server B via a network system. Server A encrypts this secret message with the public key of server B. Then server A sends a mobile agent on its way through the network system to the respective server B. For simplicity it is assumed in the following that the mobile agent only consists of its program code PA and its container containing the message. It is assumed further that the mobile agent first arrives on a server of user E on its way to server B. This scenario can be described as follows:A=>E: PA,[{mB}KB]PKA   (2)where PA is the program code of the mobile agent; mB is the secret message for server B; KB is the public key of server B; and PKA is the private key of server A as the owner of the mobile agent.
Server E can in this situation just remove the private key as the signature of server A, put the encrypted message mB in its own agent and sign the whole data container with its own private key PKE. Then server E can send the mobile agent to server B, which can be described as follows:E =>B: PE,[{mB}KB]PKE, B: PE,[{mB}KB]PKE =>{{mB}KB}PKB=mB   (3)where PE describes the program code of the mobile agent owned by server E, and PKE describes the signature, namely the private key of server E as the owner of the new mobile agent.
Server B decrypts the message mB unaware of server E's intents and makes it available to the actual mobile agent. If server E programs its mobile agent's code PE in a way that it keeps track of the message mB, then server E has full access to this secret message mB when the mobile agent returns back to server E, which can be described as follows:B=>E:PE,[{mB}KB]PKE, mB   (4)
The purpose of another existing method described in the following and further described in the reference “Green, S., Somers, F., Hurst, L., Evans, R., Nangle, B., Cunningham, P.; Software agent: A review, May (1997)” is to add data that an agent finds on a server to a secure data container. It is assumed in the following, as already mentioned, that the servers within the network system are all provided with a pair of a public key and a private key, respectively. Also the server from which the mobile agent is sent out, in the following called the first server, has a public key and a private key. Before sending a mobile agent on its route through the network system a nonce No is first encrypted with the public key of the first server, namely the server from which the mobile agent will be sent out. Within the scope of the present specification the term first server, agent owner and the server from which the mobile agent is sent out are used synonymously. The encrypted nonce No is kept secret and thus only known by the first server and can be written as follows:Co={No}KS0   (5)where No is the mentioned nonce; KS0 is the public key of the first server; and Co is the encrypted nonce.
When the mobile agent wants to take data Xi with it from a certain server Si, the mobile agent asks the respective server Si to sign the data Xi with its private key. Thus, a new checksum is being calculated, which can be described by the following mathematical term:Ci={Ci−1, [Xi]PKSi, Si}KS0   (6)where Ci describes the ith checksum; Ci−1 describes the (i−1)th checksum; Xi describes the data the mobile agent wants to take with it from the server Si; PKSi is the private key of server Si; Si is a server code of the server Si; and KS0 is the public key of the first server from which the mobile agent is sent out.
The mobile agent carries now the data which it takes from different servers on its route through the network system and the actual checksum that is calculated successively on the different servers. The data may be kept in a data container. The data the mobile agent takes with it remain visible to the other servers. If one wants to prevent this one can encrypt the data with the public key of the first server. When the mobile agent returns home, i.e., to the first server, it can be checked by the first server if the mobile agent has been modified on its route through the network system. To do this one proceeds in the other direction by deflating the checksum and verifying the signature on the data, which can be described by the following mathematical term:{Ci}PKS0=Ci−1, [Xi]PKSi, Si   (7)where Ci is the ith checksum; PKS0 is the private key of the first server; Ci−1 is the (i−1)th checksum; Xi is the data the mobile agent has gathered from the server Si; PKSi is the private key of server Si; and Si is a server code of server Si itself.
When at a certain point a verification of the signature fails the data that has been checked so far can be regarded as trustable, but the data further contained in the remaining checksum cannot be trusted anymore. When finally the whole checksum has been successfully deflated, one should get the nonce No so that it is certain that the data container is part of the mobile agent and it is not the data container of another mobile agent.
This described method also makes use of classic cryptographic techniques to protect a data transfer of a mobile agent. However, since the mobile agents migrate from one server to another before returning to their home server, the mobile agents need additional protection. This will become clear from the description of the following attack.
It is assumed in the following that a first server S0 sends out a mobile agent that is intended to reach a specific server B. On its way through the network the mobile agent from server S0 arrives at an intermediary server E. It is supposed that server E gets the mobile agent from server S0 and that server E knows an old value of a checksum Ci of a sequence of checksums C1 to Cn where i is smaller that n. This is possible for example if there is a loop in the route of the mobile agent on its way through the network system or if server E collaborates with another server where the mobile agent already went on its route through the network. Server E can now just starting from the ith element, leave elements out of the data container, change or add elements in the name of other servers. To do this server E makes its own mobile agent that carries a message Xi+1 with it that server E wants to add at the (i+1)th position and its own data container. Server E sends its own mobile agent with program code PE together with the checksum Ci to server B which can be described as follows:E=>B: PE, Xi+1, Ci   (8)
The mobile agent of server E asks server B to sign the data with its private key and to calculate a new checksum Ci+1 and to give it back to the mobile agent which then returns back to server E which can be described as follows:B=>E: PE, Ci+1={Ci, [Xi+1]PKB, B }KE   (9)where PE is the program code of the mobile agent of server E; PKB is the private key of server B; KE is the public key of server E; Ci+1 and Ci are the respective checksums; and Xi+1 are the data server E wants to add at the (i+1)th position.
That means that server E sends its mobile agent to server B in order to let server B add the message Xi+1 to the data container. When the mobile agent gets back home to server E, server E decrypts the checksum with its private key and encrypts it again with the public key from server S0. Server E can in this way continue until it is satisfied with the result. Then it can release the mobile agent from server S0 with the forged data container and send it back to server S0 which can be described as follows:E=>S0: PS0, Ci+1={Ci, [Xi+1]PKB, B }KS0   (10)where PS0 is a program code of the mobile agent from server S0; KS0 is the public key of server S0 and Ci+1; and Ci are the respective checksums. Server S0 has no possibility to detect the malicious behavior of server E.
In the following, two methods are rudimentary described wherein each method meets one of the above-mentioned problems, respectively.
In order to make sure that one can check if the data the agent is carrying with it are really this agent's data and do not belong to another agent, a method as proposed in a previous European patent application with the application number 06 290 878.5 can be provided, the method comprising at least the following steps:                choosing a unique number and assigning it to the mobile agent,        choosing a secret symmetric key and assigning it to the data to be protected,        encoding the secret key with the second server's public key,        encrypting the secret key and the first server's public key via a wrapping function, thus forming a data authentication code,        encoding the data with the secret key, and        combining the unique number, the encoded data, the encoded secret key and the data authentication code and encoding that combination with the first server's private key, thus forming a nested structure to be decoded successively for access to the data.        
According to a possible embodiment of the method, the nested structure to be decoded for access to the data is defined as follows:[PA, r0, {SKo}KB, h(KA, SKo), {mB}SKo]PKA   (11)where PA is an agent's program code, r0 is the unique number; SKo is the secret key; KB is the second server's public key; h is the wrapping function, such as a hash function; KA is the first server's public key; PKA is the first server's private key; and mB is the data to be protected.
Coming back to the exemplary attack mentioned before, the same scenario can be described and the attack as described before can be avoided by means of the method according to a possible implementation as follows:
When the mobile agent arrives at a server of user B, user B verifies first the private key associated with the mobile agent, representing at the same time a signature from a user A as the owner of the mobile agent on the whole data structure which has been received by the server of user B. Then user B decrypts the secret symmetric key, called here SKo, with its private key, called here PKB. Then user B checks the message authentication code, that means the hash function value h of the public key KA from user A, namely the public key associated with the mobile agent, and the secret symmetric key SKo. Finally, user B decrypts the message mB and makes it available to the mobile agent, if appropriate.
The attack described before is not possible anymore since user E does not know the secret symmetric key SKo and cannot forge the hash value h(KA, SKo). User E can remove again the signature of user A, namely the private key PKA associated with the mobile agent and can replace it by its own private key PKE. Furthermore, user E can replace the mobile agent code of user A by the mobile agent code of its own agent represented by PE. Therefore, user E can send to user B the following:E=>B: [PE, r0, {SKo}KB, h (KA, SKo), {mB}SKo]PKE   (12)
Since the public key KA does not match with the private key PKE of user E with which user E signed the data structure, the verification of the hash function value h(KA, SKo) by user B will fail and user B will not decrypt the message mB and thus does not make it available to the mobile agent of user E.
According to a further possible embodiment of the method, the unique number is used only once and is calculated on basis of a program code of the mobile agent. Therefore, the data structure contains a unique number, in the above mentioned case called r0 that will be used only once and that is calculated on the basis of the program code of the mobile agent, represented in the above mentioned case by PA. Every time a user sends out a new mobile agent the user changes that unique number. This number is introduced because if not, it could be possible that an old mobile agent of a specific user can be reused. If user A, for example, sends out a mobile agent to change data about him that are kept at user B, then someone would be able to reuse an old mobile agent of user A to change the data back into the old data.
It is possible that user B maintains a list of numbers that have already been used. Therefore, user B has a control that no number can be reused, and therefore, an already used agent cannot be reused again.
According to a further possible embodiment of the method, the program code of the agent is maintained in a Java Archive file. Furthermore, it is possible that that Java Archive file is signed by the private key associated with the mobile agent which is the private key of the mobile agent's owner.
It is also possible that the Java Archive file contains the unique number assigned to the mobile agent.
The complete structure to be decoded can be defined as follows:[PA, r0]PKA+[r0, {SKo}KB, h(KA, SKo), {mB}SKo]PKA   (13)where PA is an agent's program code; r0 is the unique number; SKo is the secret symmetric key; KB is the second server's public key; h is the wrapping function; KA is the first server's public key; PKA is the first server's private key; and mB is the data to be protected. The reason why the Java Archive file may also contain the unique number is because the agent's program code and the value of the objects, i.e., the data of the mobile agent, can be serialized separately in existing agent platforms.
In order to meet the second problem, namely to add data that a mobile agent from a first server finds on a ith server of a number of servers the mobile agent has to pass according to an appropriate succession to a secure data container, a method can be applied as proposed in another previous European patent application with the application number 06 290 876.9, the method comprising the following steps:
receiving the mobile agent which has been prepared by the first server by choosing a unique number and assigning it to the mobile agent, encoding the chosen unique number with the private key of the first server, thus forming an agent specific initialization number as basis for a sequence of checksums to be computed successively by the number of servers, and sending the mobile agent together with its initialization number on its route through the network system for processing the order passing thereby the number of servers successively,
encoding in case that the mobile agent intends to take data with it when passing the ith server the initialization number together with the data with the ith server's private key and computing therewith a new server specific checksum using the public key of the first server and the checksum computed by the server right before in the succession, and
sending the mobile agent further to the next server within the succession.
According to a possible embodiment of the method the data the mobile agent takes with it from servers on its route through the network is encoded by the public key of the first server. Thereby, it can be avoided that the data remains visible to other servers when the mobile agent is on its route through the network system.
Furthermore, it is possible that the sequence of checksums is defined by the following functional rule:Ci={Ci−1,[Xi,[r0]PKS0]PKSi,Si}KS0   (14)where Ci is the ith checksum; Xi is the data from the ith server; r0 is the unique number; PKS0 is the private key of the first server; KS0 is the public key of the first server; PKSi is the private key of the ith server; Si is a code number of the ith server; i is a positive integer value.
It is assumed that the mobile agent has to pass for processing its order a succession of n servers S1, . . . , Sn, wherein n is a positive integer value. In the functional rule described above, i should be smaller or equal to n. r0 is the unique number which has not to remain secret. [r0]PKS0 corresponds to a signature from the first server from which the mobile agent is sent out.
Coming back to the exemplary attack mentioned before, the same scenario can be described and the attack as described before can be avoided by means of an implementation as follows:
When a mobile agent wants to take data with it from a certain server Si, the new checksum Ci is, as already described, the following:Ci={Ci−1, [Xi, [r0]PKS0]PKSi, Si}KS0   (15)
It is clear that the previously described attack is not possible anymore. It is supposed again that server E gets the mobile agent from the first server S0 and that server E knows an old value of the checksum Ci with i<n. This is possible, as already indicated before, if there is, for example, a loop in the route of the mobile agent or if server E collaborates with another server where the mobile agent already went. If server E uses the checksum Ci and the unique number from server S0 in its own mobile agent, then the unique number r0 gets signed with the private key of server E which is described by [r0]PKE. Server B which is asked by the mobile agent from server E to compute a new checksum by adding the data Xi+1 will determine the checksum as follows:Ci+1={Ci, [Xi+1, [r0]PKE]PKB, B}KE   (16)
In the originally proposed method the data container was initialized with {N0}KS0 to be able to check in the end if the data container truly belonged to this respective mobile agent and to prevent a server of generating its own data container. This mechanism was flawed. By using the new computational rule for computing the checksum this can be avoided. When server E receives the checksum it replaces its public key KE by the public key KS0 of the first server. Since the signature from server E, namely [r0]PKE is further signed by the private key PKB of server B when computing the new checksum Ci+1, and further server E does not know the private key of the first server, server E is not able to erase its private key PKE from the checksum, thus leaving a kind of fingerprint. Therefore, when server E sends the mobile agent from server S0 together with the falsified data and the new checksum Ci+1 back to server S0, server S0 will immediately recognize that the data container is not part of its own mobile agent, but the data container of another agent. Finally, server S0 can be sure that the data it gets by its own mobile agent have been tampered by any server on the mobile agent's route through the network.
It is possible that the unique number, r0, which does not have to remain secret, corresponds to a process identification number. That means that the chosen unit number can be at the same time associated to a specific order or process, which the mobile agent has to execute on its route through the network. It is also possible that each checksum is deflated for verifying successively the respective keys on the data thus checking the unaffected and correct processing of the order.
Apart from such provisions in order to prevent the above mentioned kinds of attacks, it may further be necessary to provide a mechanism that guarantees that a certain number of previously defined servers are being visited by the mobile agent on its route through a corresponding network system. Therefore, it would be appropriate to protect the path of a mobile agent.
Thereby, the following mechanism to protect the path of the mobile agent can be considered. Before the mobile agent is sent out from the first server SA, the path of the mobile agent is encrypted in the following way:
where ip(Si) is the ip-address of server Si, t is a unique number and “End” denotes the end of the path of the mobile agent.
Thus, the path contains the encrypted addresses of the servers that the mobile agent will visit and digital signatures to protect the integrity of the path. The path is encrypted in a nested format.
When the mobile agent arrives at server Si, server Si decrypts the internet addresses of its predecessor ip(Si−1) and of its successor ip(Si+1), the digital signature and the rest of the encrypted path that now becomes the new data structure of the route.
The digital signatures are calculated based on a unique number t, this is necessary to prevent replay attacks. They also contain the ip-addresses of the current server Si, of the previous server Si−1 and the next server Si+1. The rest of the path is also signed.
Based on “End” the server Sn can decide if it is the endpoint of the path. Thus, “End” is a configuration value. Mostly, the mobile agent will return to the first server where the mobile agent departed. The digital signatures are included in the encrypted part, to keep the path secret.
By encrypting the path in a nested format, the following attack can be prevented. Thereby, it is assumed that the original path of the mobile agent contains two servers Si and Sj, that are not located the one immediately after the other (j>i+1). Then the server Si can send a copy of the path to Sj when the mobile agent is located on the server Si. The server Sj can check so far if it is in the path of the mobile agent by trying to decrypt with his private key in a sequential way the data of the path. If in one of the attempts it is capable of obtaining the clear text, then server Sj knows that it is in the path. In this case server Sj informs server Si about this, and server Si can then send the mobile agent immediately to server Sj, whereby the servers between Si and Sj are not visited by the mobile agent. No server after Sj can detect this kind of attack.
By using the nested format as described before, this kind of attack is not possible anymore, because the path is calculated one step at a time. Because of the nested encryption of the path the servers have to be visited in the right order. In each step the address of the following server is decrypted and the remaining information of the path is still encrypted with the public key of the next server. If the verification of the signature by server Si is successful, Si can be certain that it was included in the original path, that the mobile agent comes from the correct predecessor, that the address of the following server Si+1 is correct and that all further data in the path cannot be changed.
An attack that cannot be prevented by this scheme is the following. A server Si can send information about a mobile agent, for example its identity, to all servers that are cooperating with that server Si. If the mobile agent later on, by coincidence, arrives at one of these servers, then the mobile agent can be reset to its old state when it still was at server Si and bypassed all the servers in between, as described before. Server Si has to save a copy of the mobile agent, however, in order to reuse it later on.
A previous European patent application with application number 06 291 145.8 provides a method for protecting data and path of a mobile agent from a first server within a network system with a plurality of servers. At least a number of those servers are passed by the mobile agent according to an appropriate succession which defines a path of the mobile agent. The path and data intended for any one of the servers are jointly encrypted within a nested structure, the nested structure being built up on a number of nested terms corresponding to the number of servers, each nested term being decryptable in the given succession by exactly one server of the number of servers in such a manner that each server of the number of servers gets access only to the data intended for it and to a section of the path enclosing it, respectively.
The principle of the path protection is described by formula (17).
Because of the nested structure of the path the servers have to be visited in the right order, namely in the right chronology. If the verification of the signature by Si is successful, Si can be certain that it was included in the original path, that the mobile agent comes from the correct predecessor, that the address of the following server is correct and that all further data in the path cannot be changed. In order to protect the data of the mobile agent it is possible to add those data of the nested path scheme to the other data that are targeted to the different servers on the path. A suitable data protection mechanism is already described in the already mentioned previous application with the application number 06 290 878. This can be described, for example, by the following mathematical term:Data—Si=[r0, ip(Si−1), ip(Si), {SiKo}KSi, h(KS0, SiKo), {m′i}SiKo]PKS0   (18)where r0 is a unique number; SiKo is the respective server's secret key; KSi is the respective server's public key; h is the wrapping function; KS0 is the first server's public key; PKS0 is the first server's private key and m′i is the ith term of the nested terms which is defined as follows:m′i=mi, ip(Si+1), Data—Si+1   (19)where i is a positive integer value, mi is the data intended for the ith server Si. m′i comprises the data of the nested path scheme.
The data of the nested path scheme is added hereby to the other data that are targeted to the different servers on the path. The unique number, t, which has already been introduced before, corresponds generally to the unique number r0.
Thus, the mechanism to protect the data of the mobile agent becomes now a nested data structure.
Furthermore, it is also possible to use a mechanism already introduced before to add data to the mobile agent in a secure way. Every time a mobile agent reaches a server, the server has to add at least his identity to a secure data container even if no other data are collected at that server. This way one can check when the mobile agent is back home if the mobile agent has completed his full path. The mechanism which can be used to add data to the mobile agent in the secure way can be described by the following functional rule:Ci={Ci−1,[Xi,[r0]PKS0]PKSi,Si}KS0   (20)where Ci is the ith checksum; Xi is the data to be added at the ith server; r0 is the unique number; PKS0 is the private key of the first server; KS0 is the public key of the first server; PKSi is the private key of the ith server; Si is a code number of the ith server; and i is a positive integer value.
However, it is not possible to check whether the agent has completed a part of the path on the route. No server on the path can see the full path that the mobile agent should follow. This is in most cases quite convenient with respect to privacy of information.
However, it would be convenient if the initial path of the mobile agent could be extended on the route. One of the main advantages of using mobile agents is that they can roam the internet autonomously in order to retrieve information. By specifying an initial path to follow, this feature of mobile agents would be severally restricted, therefore it is important to provide a mechanism to securely extend the initial path based on conditions in the execution environment.